home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / qed_397 / sourcen / dd.c < prev    next >
C/C++ Source or Header  |  1997-01-04  |  8KB  |  400 lines
  1. #include <atarierr.h>
  2.  
  3. #include "global.h"
  4. #include "comm.h"
  5. #include "edit.h"
  6. #include "find.h"
  7. #include "icon.h"
  8. #include "projekt.h"
  9. #include "windows.h"
  10. #include "dd.h"
  11.  
  12. #define DD_OK            0
  13. #define DD_NAK         1
  14. #define DD_EXT         2
  15. #define DD_LEN         3
  16.  
  17. #define DD_NUMEXTS    8
  18. #define DD_EXTSIZE    32
  19. #define DD_NAMEMAX    128
  20. #define DD_TIMEOUT    2000
  21.  
  22. /* exportierte Variablen *****************************************************/
  23. GLOBAL PATH        drag_filename;        /* Dateiname/Pfad wurde gedragged */
  24. GLOBAL UBYTE    *drag_data;            /* Daten wurden gedragged */
  25. GLOBAL LONG        drag_data_size;    /* Die Länge der Daten */
  26.  
  27. /* lokale Variablem **********************************************************/
  28. LOCAL VOID    *oldsig;
  29.  
  30.  
  31. /* DD Empfang ****************************************************************/
  32. LOCAL WORD parse_ARGS(UBYTE *str)
  33. {
  34.     WORD        cnt = 1;
  35.     UBYTE     *c = str;
  36.     BOOLEAN    in_quote = FALSE;
  37.  
  38.     while (*c)
  39.     {
  40.         switch (*c)
  41.         {
  42.             case ' ' :
  43.                 if (!in_quote)
  44.                 {
  45.                     *c = '\0';
  46.                     cnt++;
  47.                 }
  48.                 break;
  49.             case '\'' :
  50.                 strcpy(c, c + 1);
  51.                 if (!in_quote)
  52.                     in_quote = TRUE;
  53.                 else
  54.                 {
  55.                     if (*c != '\'')
  56.                     {
  57.                         in_quote = FALSE;
  58.                         *c = 0;
  59.                         if (c[1])
  60.                             cnt++;
  61.                     }
  62.                 }
  63.                 break;
  64.             default:
  65.                 break;
  66.         } /* switch */
  67.         c += 1;
  68.     } /* while */
  69.     return cnt;
  70. }
  71.  
  72. LOCAL VOID insert(WINDP w, WORD kstate, UBYTE *filename)
  73. {
  74.     BOOLEAN    alt;
  75.  
  76.     global_shift = (kstate & 3);
  77.     alt = (kstate & 0x8);
  78.     strcpy(drag_filename, filename);
  79.  
  80.     if (w->class == CLASS_PROJEKT)
  81.     {
  82.         if (filename[strlen(filename) - 1] == '\\')            /* Pfad */
  83.             Icon_drag(w->link, DRAGDROP_PATH);                    /*  -> Datei suchen */
  84.         else                                                                /* Datei */
  85.             Icon_drag(w->link, DRAGDROP_FILE);                    /*  -> einfügen */
  86.     }
  87.     else
  88.     {
  89.         if (global_shift ||                                             /* Name bzw. */
  90.              (filename[strlen(filename) - 1] == '\\'))        /* Pfad einfügen */
  91.             Icon_drag(w->link, DRAGDROP_PATH);
  92.         else if (alt)                                                    /* Inhalt einfügen */
  93.             Icon_drag(w->link, DRAGDROP_FILE);
  94.         else                                                                /* neues Fenster öffnen */
  95.         {
  96.             if (filematch(filename, "*.QPJ"))
  97.                 load_projekt(filename, TRUE, -1, -1, NULL);
  98.             else
  99.                 load_edit(filename, TRUE, -1, -1, NULL);
  100.         }
  101.     }
  102. }
  103.  
  104. LOCAL VOID parse(UBYTE *obname, UBYTE *cmdline, WINDP w, WORD kstate)
  105. {
  106.     WORD    comps = parse_ARGS(cmdline);
  107.     UBYTE *c = cmdline;
  108.  
  109.     drag_data_size = comps;            /* Anzahl der ARGS merken */
  110.     while (comps - 1)
  111.     {
  112.         insert(w, kstate, c);
  113.         c += strlen(c) +1;
  114.         comps--;
  115.     }
  116.     insert(w, kstate, c);
  117. }
  118.  
  119. LOCAL LONG dd_open_pipe(WORD pnum)
  120. {
  121.     UBYTE pipename[20];
  122.     LONG    fd;
  123.  
  124.     sprintf(pipename, "U:\\PIPE\\DRAGDROP.%c%c", (pnum & 0xff00) >> 8, pnum & 0xff);
  125.     if ((fd = Fopen(pipename, 2)) > 0)
  126.         oldsig = Psignal(SIGPIPE, (void *) SIG_IGN);
  127.     return fd;
  128. }
  129.  
  130. LOCAL VOID dd_close(LONG fd)
  131. {
  132.     Psignal(SIGPIPE, oldsig);
  133.     Fclose((short) fd);
  134. }
  135.  
  136. LOCAL LONG dd_open(WORD pipe_num, CONST UBYTE *extlist)
  137. {
  138.     LONG    fd;
  139.     UBYTE outbuf[DD_EXTSIZE + 2];
  140.  
  141.     fd = dd_open_pipe(pipe_num);
  142.     if (fd < 0)
  143.         return fd;
  144.  
  145.     memset(outbuf, 0, DD_EXTSIZE + 2);
  146.     outbuf[0] = DD_OK;
  147.     strncpy(outbuf + 1, extlist, DD_EXTSIZE);
  148.     if (Fwrite((short) fd, DD_EXTSIZE + 1, outbuf) != DD_EXTSIZE + 1)
  149.     {
  150.         dd_close(fd);
  151.         return -1L;
  152.     }
  153.     return fd;
  154. }
  155.  
  156. LOCAL BOOLEAN dd_getheader(LONG fd, UBYTE *obname, UBYTE *fname, UBYTE *datatype,
  157.                                     LONG *size)
  158. {
  159.     WORD        hdrlen, cnt, slen;
  160.     UBYTE     buf[PATH_MAX + DD_NAMEMAX + 1];
  161.  
  162.     if (Fread((short) fd, 2, &hdrlen) != 2)
  163.         return FALSE;
  164.     if (hdrlen < 8)
  165.         return FALSE;
  166.  
  167.     if (Fread((short) fd, 4, datatype) != 4)
  168.         return FALSE;
  169.     datatype[4] = '\0';
  170.  
  171.     if (Fread((short) fd, 4, size) != 4)
  172.         return FALSE;
  173.     hdrlen -= 8;
  174.     cnt = hdrlen;
  175.  
  176.     if (cnt > PATH_MAX + DD_NAMEMAX)
  177.         cnt = PATH_MAX + DD_NAMEMAX;
  178.     if (Fread((short) fd, cnt, buf) != cnt)
  179.         return FALSE;
  180.     buf[PATH_MAX + DD_NAMEMAX] = '\0';
  181.     hdrlen -= cnt;
  182.     slen = (short) strlen(buf);
  183.  
  184.     if (slen < DD_NAMEMAX)
  185.         strcpy(obname, buf);
  186.     if (slen < PATH_MAX + DD_NAMEMAX)
  187.     {
  188.         UBYTE *fp = buf + slen + 1;
  189.  
  190.         slen = (short) strlen(fp);
  191.         if (slen < PATH_MAX)
  192.             strcpy(fname, fp);
  193.     }
  194.  
  195.     while (hdrlen)
  196.     {
  197.         WORD    cnt = hdrlen;
  198.  
  199.         if (cnt > sizeof(buf))
  200.             hdrlen = (short) sizeof(buf);
  201.         Fread((short) fd, cnt, buf);
  202.         hdrlen -= cnt;
  203.     }
  204.     return TRUE;
  205. }
  206.  
  207. LOCAL BOOLEAN dd_reply(LONG fd, UBYTE ack)
  208. {
  209.     if (Fwrite((short) fd, 1L, &ack) != 1)
  210.     {
  211.         dd_close(fd);
  212.         return FALSE;
  213.     }
  214.     return TRUE;
  215. }
  216.  
  217. GLOBAL VOID    hndl_dd(WORD *msg)
  218. {
  219.     WINDP w_dest = find_window(msg[3]);
  220.     LONG    fd,
  221.             size;
  222.     UBYTE obname[DD_NAMEMAX],
  223.             ext[5],
  224.             fname[PATH_MAX],
  225.             ourexts[DD_EXTSIZE] = "ARGS.TXT";
  226.  
  227.     if (w_dest != NULL)
  228.     {
  229.         fd = dd_open(msg[7], ourexts);
  230.         if (fd < 0)
  231.             return ;
  232.  
  233.         do
  234.         {
  235.             if (!dd_getheader(fd, obname, fname, ext, &size))
  236.             {
  237.                 dd_close(fd);
  238.                 return;
  239.             }
  240.             if (!strncmp(ext, "ARGS", 4))
  241.             {
  242.                 UBYTE    *cmdline = Malloc(size +1);
  243.  
  244.                 if (!cmdline)
  245.                 {
  246.                     dd_reply(fd, DD_LEN);
  247.                     continue;
  248.                 }
  249.                 dd_reply(fd, DD_OK);
  250.                 Fread((short) fd, size, cmdline);
  251.                 dd_close(fd);
  252.                 cmdline[size] = 0;
  253.                 parse(obname, cmdline, w_dest, msg[6]);
  254.                 Mfree(cmdline);
  255.                 drag_data_size = 0;
  256.                 return ;
  257.             }
  258.             if (strncmp(ext, ".TXT", 4) == 0 )
  259.             {
  260.                 drag_data = Malloc(size + 1);
  261.                 /* ^^ wird nach dem Einfügen in edit.c wieder freigegeben! */
  262.                 drag_data_size = size;
  263.                 if (drag_data == NULL)
  264.                 {
  265.                     dd_reply(fd, DD_LEN);
  266.                     continue;
  267.                 }
  268.                 dd_reply(fd, DD_OK);
  269.                 Fread((short) fd, drag_data_size, drag_data);
  270.                 dd_close(fd);
  271.                 drag_data[drag_data_size] = 0;
  272.                 Icon_drag(w_dest->link, DRAGDROP_DATA);
  273.                 return ;
  274.             }
  275.         }
  276.         while (dd_reply(fd, DD_EXT));
  277.     }
  278. }
  279.  
  280.  
  281. /* DD Senden *****************************************************************/
  282.  
  283. #if 0
  284. #include "debug.h"
  285.  
  286. LOCAL WORD dd_create(WORD rcvr_id, WORD window, MKINFO *mk, ULONG format[8])
  287. {
  288.     UBYTE    pipe[24];
  289.     LONG    handle_mask;
  290.     WORD    handle, i;
  291.  
  292.     strcpy(pipe, "U:\\PIPE\\DRAGDROP.AA" );
  293.     pipe[18] = 'A' - 1;
  294.     do                                                        /* erste freie Pipe suchen */
  295.     {
  296.         pipe[18]++;
  297.         if (pipe[18] > 'Z')
  298.         {
  299.             pipe[17]++;
  300.             if (pipe[17] > 'Z')
  301.                 return( -1 );
  302.         }
  303.         handle = (WORD)Fcreate(pipe, 0x02);        
  304.     } 
  305.     while (handle == EACCDN);
  306.  
  307.     if (handle < 0)
  308.         return(handle);
  309.  
  310.     memset(msgbuff, 0, (WORD)sizeof(msgbuff));
  311.     msgbuff[0] = AP_DRAGDROP;
  312.     msgbuff[3] = window;
  313.     msgbuff[4] = mk->mox;
  314.     msgbuff[5] = mk->moy;
  315.     msgbuff[6] = mk->kstate;
  316.     msgbuff[7] = (((WORD) pipe[17]) << 8 ) + pipe[18];
  317.     
  318.     if (!send_msg(rcvr_id))
  319.     {
  320.         Fclose(handle);
  321.         return(-2);
  322.     }
  323.  
  324.     handle_mask = 1L << handle;
  325.     i = Fselect(DD_TIMEOUT, &handle_mask, 0L, 0L);
  326.     if (i && handle_mask)
  327.     {
  328.         UBYTE    reply;
  329.         
  330.         if (Fread(handle, 1L, &reply) == 1)
  331.         {
  332.             if (reply == DD_OK)
  333.             {
  334.                 if (Fread(handle, DD_EXTSIZE, format) == DD_EXTSIZE)    
  335.                 {
  336.                     oldsig = Psignal(SIGPIPE, (void *) SIG_IGN);
  337.                     return(handle);
  338.                 }
  339.             }
  340.         }
  341.     }
  342.     Fclose(handle);
  343.     return(-1);
  344. }
  345.  
  346. LOCAL WORD dd_stry(WORD handle, ULONG format, UBYTE *name, LONG size)
  347. {
  348.     WORD    str_len;
  349.     WORD    hdr_len;
  350.     
  351.     str_len = (WORD)strlen(name) + 1;
  352.     hdr_len = 4 + 4 + str_len;
  353.     if (Fwrite(handle, 2, &hdr_len) == 2)
  354.     {
  355.         LONG    written;
  356.         
  357.         written = Fwrite(handle, 4, &format);
  358.         written += Fwrite(handle, 4, &size);
  359.         written += Fwrite(handle, str_len, name);
  360.         
  361.         if (written == hdr_len)
  362.         {
  363.             UBYTE    reply;
  364.             
  365.             if (Fread(handle, 1, &reply) == 1)
  366.                 return(reply);
  367.         }
  368.     }    
  369.     return(DD_NAK);
  370. }
  371.  
  372. GLOBAL VOID send_dd(WORD wh, MKINFO *mk, WORD data_type)
  373. {
  374.     WORD        pipe, app, d;
  375.     ULONG        types[DD_NUMEXTS];
  376.     LONG        ret;
  377.     
  378.     wind_get(wh, WF_OWNER, &app, &d, &d, &d);
  379.     pipe = dd_create(app, wh, mk, types);
  380.     if (pipe > 0)
  381.     {
  382.         switch (data_type)
  383.         {
  384.             case DRAGDROP_FILE :
  385.                 break;
  386.             case DRAGDROP_PATH :
  387.                 if (dd_stry(pipe, 'ARGS', "ARGS.TXT", strlen(drag_filename) + 1) == DD_OK)
  388.                 {
  389.                     ret = Fwrite(pipe, strlen(drag_filename) + 1, drag_filename);
  390.                     Fclose(pipe);
  391. Debug("qed: D&D to Win %d, App %d\n", wh, app);
  392.                 }
  393.                 break;
  394.             case DRAGDROP_DATA :
  395.                 break;
  396.         }
  397.     }
  398. }
  399. #endif
  400.